System and method for integrating resources in a network

ABSTRACT

A method for integrating a resource in a network includes receiving at a first adapter a command associated with a function to be performed by a resource. The method also includes receiving a first script associated with the command, and interpreting the first script to produce one or more first byte codes. The method further includes causing a second adapter to receive a second script. The second adapter is operable to interpret the second script into one or more second byte codes. In addition, the method includes executing the one or more first byte codes, and invoking execution of the one or more second byte codes at the second adapter. The execution of the byte codes at the first and second adapters is operable to invoke the function in and facilitate communication with the resource.

PRIORITY CLAIM

This patent application is a Continuation of U.S. patent application Ser. No. 10/226863, filed Aug. 23, 2002, entitled System and Method for Integrating Resources in a Network, the contents of which are incorporated herein by reference.

TECHNICAL FIELD

This disclosure relates generally to the field of computer systems, and more particularly to a system, a method, and a program product for integrating resources in a network.

BACKGROUND

Integration adapters typically allow a new product to be installed in and work with existing or legacy computing systems. Each adapter typically allows the new product to communicate using the appropriate protocols and formats supported by a particular computing system. In general, providing more adapters typically increases the number of computing systems that the new product can work with, which also increases the number of potential customers for the new product. An integration adapter is often created by a skilled programmer who follows the software development cycle. The software development cycle typically includes steps for designing a software program, writing software code, compiling the code, building an executable program, deploying the executable program, and testing or debugging the executable program. This often can be a time consuming task.

BRIEF DESCRIPTION OF THE DRAWINGS

For a more complete understanding of this disclosure, reference is now made to the following descriptions, taken in conjunction with the accompanying drawings, in which:

FIG. 1 illustrates an example system for integrating a resource in a network;

FIG. 2 illustrates an example data flow for integrating a resource in a network;

FIG. 3 illustrates another example data flow for integrating a resource in a network;

FIG. 4 illustrates an example method for integrating a resource at a first adapter;

FIG. 5 illustrates an example method for integrating a resource at a second adapter;

FIG. 6 illustrates another example method for integrating a resource at a first adapter;

FIG. 7 illustrates another example method for integrating a resource at a second adapter; and

FIG. 8 illustrates an example method for persisting scripts in a database.

DETAILED DESCRIPTION OF EXAMPLE EMBODIMENTS

FIG. 1 illustrates an example system 100 for integrating a resource in a network. In the illustrated embodiment, system 100 includes servers 102, a gateway 104, resources 106, a network 108, and clients 110. Other embodiments of system 100 may be used without departing from the scope of this disclosure.

In one aspect of operation, server 102 and/or gateway 104 include adapter modules 124, 126, which help to integrate a resource 106 into system 100. The resource 106 may be a computing system or a device. Adapter modules 124, 126 integrate the resource 106 by collectively executing scripts, which define the function or functions to be performed by server 102 and/or gateway 104. Adapter modules 124, 126 can also transfer or marshal data between the executing scripts. The executing scripts cause server 102 and/or gateway 104 to behave as an adapter. For example, the scripts may act to translate data so that server 102 can communicate with the resource 106, even when they use different protocols and formats. Adapter module 124 could also individually execute script to provide a service in system 100. For example, the script may cause server 102 to analyze data for a specific condition and invoke the execution of another script if the condition is met.

In the illustrated embodiment, server 102 is coupled to network 108. Server 102 could also be coupled to gateway 104. In this specification, the term “couple” refers to any direct or indirect communication between two or more components, whether or not those components are in physical contact with one another. Also, the term “communication” refers to communication between physically separate components or between components within a single physical unit. Server 102 performs one or more functions to integrate a resource 106 in system 100. Server 102 may include any hardware, software, firmware, or combination thereof operable to perform integration functions in system 100.

Gateway 104 is coupled to server 102 and to a resource 106. Gateway 104 facilitates access to the resource 106. For example, gateway 104 may communicate with server 102 and exchange information with resource 106. Gateway 104 may comprise any hardware, software, firmware, or combination thereof operable to provide access to a device or system being integrated. The use of gateway 104 may or may not be required to access a resource 106 in system 100. As shown in FIG. 1, a gateway 104 could be used to integrate some resources 106 but not other resources 106.

Resource 106 represents a computing device or system being integrated into system 100 by server 102 and/or gateway 104. Resource 106 may represent any suitable system or device. In the illustrated example, resource 106 represents a database information system or an enterprise resource planning (ERP) system. Other suitable resources, such as transaction processing systems, could also be used and integrated into system 100.

Network 108 is coupled to server 102 and clients 1 10. Network 108 facilitates communication between components of system 100. For example, network 108 may communicate Internet Protocol (IP) packets, frame relay frames, Asynchronous Transfer Mode (ATM) cells, or other suitable information between network addresses. Network 108 may include one or more local area networks (LANs), metropolitan area networks (MANs), wide area networks (WANs), all or a portion of a global network such as the Internet, or any other communication system or systems at one or more locations.

Client 110 is coupled to network 108. Client 110 may perform any of a variety of functions in system 100. For example, client 110 may communicate with server 102 and submit a request to perform a function in resource 106. Server 102 and/or gateway 104 act as an adapter so that the requested function can be invoked and performed in the resource 106. Client 110 accesses server 102 using a browser 112, a client application 114, or in any other suitable manner. Client 110 may include any hardware, software, firmware, or combination thereof operable to communicate with server 102.

In the illustrated example, server 102 includes a processor 116 and a memory 118. Processor 116 executes instructions and manipulates data to perform the operations of server 102. Although FIG. 1 illustrates a single processor 116 in server 102, multiple processors 116 may be used according to particular needs. Memory 118 stores and facilitates retrieval of information used by processor 116 to perform the functions of server 102. Memory 118 may, for example, store instructions to be performed by processor 116 and data used by processor 116. Memory 118 may include any hardware, software, firmware, or combination thereof operable to store and facilitate retrieval of information.

In the illustrated example, server 102 comprises a JAVA 2 Platform Enterprise Edition (J2EE™) server. In this example embodiment, server 102 includes one or more Enterprise JAVABEANS 120. Server 102 may also include one or more JAVASERVER Pages (JSP™) servlets 122. FIG. 1 illustrates only example embodiments of server 102, and server 102 could represent any other suitable platform. For example, other protocols that support the use of JAVA objects or other objects can be used in system 100.

JAVABEANS 120 represent JAVA applications that implement business or other logic in system 100. Any type of logic may be implemented in JAVABEANS 120 to perform any suitable function. For example, the logic implemented in JAVABEANS 120 may allow a user using a client 110 to order products from different vendors. In this example, JAVABEANS 120 may submit product orders to the resources 106, which represent the vendors' order processing systems. The logic implemented in JAVABEANS 120 may also allow a user using client 110 to track shipments being handled by various shipping carriers. In that case, JAVABEANS 120 may retrieve information about specific shipments from the resources 106, which represent the carriers' tracking systems. Other or additional JAVABEANS 120 could be used in system 100.

JAVABEANS 120 can be invoked directly from a client 110 using client application 114. JAVABEANS 120 could also be invoked from a client 110 using a browser 112, where server 102 uses one or more JSP servlets 122 to generate web pages that can be displayed to a user at client 110. The user may then invoke a function of server 102, such as by initiating execution of a JAVABEAN 120, using the web page.

To facilitate integration of a resource 106 into system 100, server 102 includes an adapter module 124, and server 102 or gateway 104 includes an adapter module 126.

Adapter modules 124, 126 may each receive one or more scripts, such as by retrieving scripts stored in a database 128. The scripts identify the actions to be performed by adapter modules 124, 126. In particular, the scripts identify how adapter modules 124, 126 operate in order to integrate a resource 106 with server 102. Adapter modules 124, 126 compile or interpret the scripts into byte codes and execute the byte codes. Adapter modules 124, 126 may further communicate with one another and exchange information during the execution of the scripts. By executing the scripts and exchanging information, adapter modules 124, 126 may allow information, such as function invocations and status messages, to be communicated between server 102 and resource 106. Adapter module 124 could also individually execute a script to perform a function in server 102, such as analyzing data. Adapter modules 124, 126 may each comprise any hardware, software, firmware, or combination thereof operable to execute scripts.

In one embodiment, adapter modules 124, 126 represent JAVA applications that run on or under one or more JAVA Virtual Machines (JVM™). In a particular embodiment, adapter module 124 executes in a (J2EE™) container, and adapter module 126 is not contained in a (J2EE™) container. In this embodiment, adapter module 124 may communicate with adapter module 126 using at least one of the Remote Method Invocation (RMI), JAVA Messaging Service (JMS™), and JAVA Data Base Connection (JDBC™) mechanisms. Because adapter module 124 may only be able to communicate using a mechanism defined in the (J2EE™) standard, adapter module 124 may be unable to communicate directly with the resource 106 being integrated. Adapter module 126 can communicate using any or all of the (J2EE™) mechanisms, plus any other communication mechanism suitable for communicating with a resource 106 being integrated. Because adapter module 126 may not be limited to communicating using a (J2EE™) mechanism, adapter module 126 may communicate with the resource 106 being integrated. Adapter modules 124, 126 may also communicate with one another using a (J2EE™) mechanism and exchange information so that the resource 106 is integrated into system 100.

As a particular example, resource 106 may represent a directory-based file system. In the (J2EE™) environment, the RMI, JMS, and JDBC mechanisms may not support a facility that allows server 102 to access files on the directory. Adapter modules 124, 126 execute scripts to allow server 102 to read information from or write information to a file in the directory. For example, adapter module 126 may not be restricted to communicating using (J2EE™) mechanisms, so adapter module 126 could access files on the directory. Adapter module 124 could communicate with adapter module 126 and inform adapter module 126 of what information should be read from or written to resource 106. If writing information to the directory, adapter module 124 could communicate the information to adapter module 126 using one or more of the (J2EE™) communication mechanisms. Similarly, if reading information from the directory, adapter module 126 could make the information available to adapter module 124 using one or more of the (J2EE™) communication mechanisms.

Although FIG. 1 illustrates one example of a system 100 for integrating a resource in a network, various changes may be made to system 100. For example, while FIG. 1 illustrates the use of a (J2EE™) server 102, other suitable servers may be used.

FIG. 2 illustrates an example data flow 200 for integrating a resource in a network. While FIG. 2 assumes that a server 202 and a gateway 204 are collectively used to integrate a resource 206, the functionality described with respect to gateway 204 could be implemented in server 202.

In FIG. 2, server 202 includes an adapter module 224, and gateway 204 includes an adapter module 226. Server 202 could represent any suitable computing device, such as a (J2EE™) server, and gateway 204 could represent any suitable gateway device.

In this example, gateway 204 has access to a script directory 228. Script directory 228 may include any hardware, software, firmware, or combination thereof operable to store and facilitate retrieval of information. Also, script directory 228 may use any of a variety of data structures, arrangements, or compilations to store and facilitate retrieval of the information.

In the illustrated example, script directory 228 stores scripts 250, 252. Scripts 250, 252 represent scripts that can be compiled/interpreted and executed by adapter modules 224, 226. Scripts 250, 252 may represent source Jython or Python scripts, a script library, a JAVA class, or any other suitable structure containing one or more scripts. The scripts 250, 252 facilitate integration of and communication with a resource 206, such as by converting data from a protocol used by server 202 to a protocol used by resource 206. Script 250 could represent a script executed by adapter module 224, and script 252 could represent a script executed by adapter module 226.

Adapter modules 224, 226 could represent any suitable element for compiling/interpreting and executing scripts. In one embodiment, adapter module 224 may represent a JAVABEANS component that conforms to JAVA container boundaries, while adapter module 226 is not contained in a JAVA container. In this embodiment, each adapter module 224, 226 is associated with one or more JAVABEAN properties. In a particular embodiment, the properties of an adapter module 224, 226 identify the location of script directory 228 and the script 250, 252 associated with that adapter 224, 226.

In one aspect of operation, adapter module 224 may execute a script 250 to provide a service. For example, adapter module 224 may receive a request to perform a function, such as by receiving a command from an Enterprise JAVABEAN 120 of FIG. 1 to analyze data and determine if a condition is satisfied. Adapter module 224 communicates a message 260 to adapter module 226, which instructs adapter module 226 to retrieve script 250 from directory 228. Adapter module 226 retrieves script 250 (represented as data flow 262) and communicates script 250 to adapter module 224 (represented as data flow 264). Adapter module 224 receives, compiles or interprets, and executes script 250. The script 250 causes adapter module 224 to analyze the data and determine if the condition is satisfied.

In another aspect of operation, adapter modules 224, 226 may execute scripts 250, 252 to act as an adapter. For example, adapter module 224 may receive a request to provide adapter functionality, such as by receiving a command from an Enterprise JAVABEAN 120 to invoke a function in resource 206. Adapter module 224 communicates message 260 to adapter module 226, causing adapter module 226 to retrieve and provide script 250 to adapter module 224. Adapter module 224 also communicates a message 266 to adapter module 226. Message 266 instructs adapter module 226 to retrieve script 252 (represented as data flow 268) and compile/interpret script 252. Server 202 can execute script 250, and the execution of script 250 may generate a message 270 that invokes the execution of script 252 in gateway 204. Server 202 and gateway 204 can also marshal or transfer data between the executing scripts 250, 252 (represented as data flows 272). By executing the scripts 250, 252 and exchanging data, server 202 and gateway 204 may act as an integration adapter and facilitate communication between server 202 and resource 206.

The messages 260, 266, 270 that cause adapter module 226 to retrieve scripts 250, 252 may represent any suitable type of instruction. For example, messages 260, 266, 270 could represent RMI calls, JMS messages, or other suitable messages.

In a particular embodiment, message 260 represents a RMI import command, message 266 represents a RMI proxy import command, and message 270 represents a RMI proxy invocation command. A proxy import makes the properties, functions, and classes of script 252 available for use by script 250. A proxy invocation command invokes the script 252 that was previously imported by a proxy command. In addition, server 202 and gateway 204 can marshal data between one another in the form of properties, function/method arguments, return values, or other suitable information.

In addition to directory 228, server 202 could also have access to a script cache 274. Cache 274 stores binary (compiled) versions of scripts 250, 252. In one embodiment, a marker 278 associated with the binary version of a script 250, 252 is compared with a marker 280 associated with the script 250, 252. As an example, the markers 278, 280 may represent date-time stamps. If the markers 278, 280 are the same, server 202 or gateway 204 may use the binary version of the script 250, 252. Otherwise, server 202 or gateway 204 retrieves and compiles/interprets the script 250, 252. Caching binary versions of scripts 250, 252 may help to speed the operation of server 202 and gateway 204 by reducing the need to compile or interpret scripts 250, 252 each time they are used.

In another embodiment, cache 274 may be used in place of directory 228. For example, cache 274 could be used when scripts 250, 252 are being developed. Cache 274 would store the latest versions of scripts 250, 252 in binary form. After development is complete, the binary forms of scripts 250, 252 can be made available, while the source scripts 250, 252 are not. This could help to protect the source scripts 250, 252 from being modified after development is complete.

The use of scripts 250, 252 may help to simplify the development of an adapter for resource 206. For example, rather than requiring that an adapter be developed in a complex programming environment by an experienced programmer, scripts 250, 252 could be written in a scripting language such as Jython or Python using a text editor 282. The scripts 250, 252 could also be developed using a shorter development cycle. For example, a developer could design, write, and test/debug the scripts 250, 252 without the need to perform the other steps of the software development cycle.

Although FIG. 2 illustrates one example of a data flow 200 for integrating a resource in a network, various changes may be made to FIG. 2. For example, gateway 204 could be coupled to any number of resources 206. Also, any suitable type of messages 260, 264, 266, 270 could be used. In addition, scripts 250, 252 in directory 228 need not include markers 280, and cache 274 need not be included.

FIG. 3 illustrates another example data flow 300 for integrating a resource in a network. While FIG. 3 assumes that a server 302 and a gateway 304 are collectively used to integrate a resource 306, the functionality described with respect to gateway 304 could be implemented in server 302.

In FIG. 3, server 302 includes an adapter module 324, and gateway 304 includes an adapter module 326. Server 302 and gateway 304 may be the same as or similar to server 202 and gateway 204 of FIG. 2. In this example, server 302 has access to a script repository 328, which stores scripts 350, 352.

In one aspect of operation, adapter module 324 may execute a script 350 to provide a service. In this embodiment, adapter module 324 may retrieve script 350 from repository 328 (represented as data flow 360). Adapter module 324 then compiles or interprets and executes script 350. The script 350 causes adapter module 324 to perform the function and provide the service.

In another aspect of operation, adapter modules 324, 326 may execute scripts 350, 352 to act as an adapter. Adapter module 324 retrieves and compiles/interprets script 350. Adapter module 324 also retrieves script 352 from repository 328 (represented as data flow 362) and communicates the script 352 to adapter module 326 using message 364. Message 364 may, for example, represent a RMI proxy import command. Adapter module 326 can then compile/interpret script 352. Adapter module 324 executes script 350, and during execution adapter module 324 communicates message 366 to invoke the execution of script 352 in gateway 304. Server 302 and gateway 304 can also marshal or transfer data between one another (represented as data flows 368).

In addition to or in place of repository 328, server 302 could have access to a script cache 374. Cache 374 stores binary versions of scripts 350, 352. Server 302 may use markers 378, 380 in the same or similar manner as described with respect to server 202 of FIG. 2.

Although FIG. 3 illustrates another example of a data flow 300 for integrating a resource in a network, various changes may be made to FIG. 3. For example, gateway 304 could be coupled to any number of resources 306. Also, any suitable type of messages 364, 366 could be used. In addition, scripts 350, 352 in repository 328 need not include markers 380, and cache 374 need not be included.

FIG. 4 illustrates an example method 400 for integrating a resource at a first adapter. Method 400 may be described with respect to server 202 of FIG. 2. Method 400 could also be used by another device or devices in another system.

Server 202 receives a request to perform a function at step 402. This may include, for example, adapter module 224 receiving a command from an Enterprise JAVABEAN or another component. The request could include a command to perform a particular service, a command to act as an adapter for a resource 206, or other suitable request.

Server 202 communicates a request for a first script 250 to a gateway 204 at step 404. This may include, for example, adapter module 224 communicating a RMI import command to adapter module 226 in gateway 204. Server 202 receives the first script 250 from gateway 204 at step 406. This may include, for example, adapter module 226 retrieving the script 250 from directory 228 and communicating the script 250 to adapter module 224. Server 202 compiles/interprets the first script 250 at step 408. This may include, for example, adapter module 224 interpreting a Jython script 250 into JAVA byte codes.

If the request received at step 402 represents a request for a service, server 202 invokes the compiled/interpreted script 250 at step 412. This may include, for example, adapter module 224 executing the JAVA byte codes generated at step 408. Otherwise, the request represents a request to act as an adapter. Server 202 instructs gateway 204 to retrieve and compile/interpret a second script 252 at step 414. This may include, for example, adapter module 224 communicating a proxy import command to adapter module 226. This may also include adapter module 226 retrieving the second script 252 from directory 228 and compiling/interpreting the script 252. Server 202 invokes the first script 250 at step 416. The execution of the first script 250 invokes execution of the second script 252 in gateway 204 at step 418. This may include, for example, adapter module 224 communicating a proxy invocation command to adapter module 226. At this point, the executing scripts 250, 252 may exchange information to act as an adapter to integrate a resource 206.

Although FIG. 4 illustrates one example of a method 400 for integrating a resource at a first adapter, various changes may be made to FIG. 4. For example, while FIG. 4 assumes that a server 202 and a gateway 204 are collectively used to integrate a resource 206, the functionality described with respect to gateway 204 could be implemented in server 202.

FIG. 5 illustrates an example method 500 for integrating a resource at a second adapter. Method 500 may be described with respect to gateway 204 of FIG. 2. Method 500 could also be used by another device or devices in another system.

Gateway 204 receives a request for a first script 250 at step 502. This may include, for example, adapter module 226 receiving an import command from adapter module 224 in server 202. Gateway 204 retrieves the first script 250 at step 504. This may include, for example, adapter module 226 accessing directory 228 and retrieving the script 250 from directory 228. Gateway 204 communicates the first script 250 to server 202 at step 506. This may include, for example, adapter module 226 communicating the script 250 to adapter module 224 of server 202.

If the script 250 is being used by server 202 to perform a service, method 500 ends. Server 202 may provide the service without further interactions with gateway 204.

Otherwise, server 202 and gateway 204 may act as an adapter. Gateway 204 receives an instruction to retrieve a second script 252 at step 510. This may include, for example, adapter module 226 receiving a proxy import command from adapter module 224. Gateway 204 retrieves the second script 252 at step 512. This may include, for example, adapter module 226 accessing directory 228 and retrieving the script 252 from directory 228. Gateway 204 compiles/interprets the second script 252 at step 514. This may include, for example, adapter module 226 interpreting a Jython script 252 into JAVA byte codes. Gateway 204 receives an instruction to invoke the second script 252 at step 516. This may include, for example, adapter module 226 receiving a proxy invocation command from adapter module 224. Gateway 204 invokes the second script 252 at step 518. This may include, for example, adapter module 226 executing the JAVA byte codes generated at step 514. At this point, the executing scripts 250, 252 may exchange information to act as an adapter to integrate a resource 206.

Although FIG. 5 illustrates one example of a method 500 for integrating a resource at a second adapter, various changes may be made to FIG. 5. For example, while FIG. 5 assumes that a server 202 and a gateway 204 are collectively used to integrate a resource 206, the functionality described with respect to gateway 204 could be implemented in server 202.

FIG. 6 illustrates another example method 600 for integrating a resource at a first adapter. Method 600 may be described with respect to server 302 of FIG. 3. Method 600 could also be used by another device or devices in another system.

Server 302 receives a request to perform a function at step 602, such as a request from an Enterprise JAVABEAN or other component. Server 302 retrieves the first script 350 at step 604. This may include, for example, adapter module 324 retrieving the first script 350 from a script repository 328. Server 302 compiles/interprets the first script 350 at step 606.

If the request received at step 602 represents a request for a service at step 608, server 302 invokes the compiled/interpreted script 350 at step 610. Otherwise, the request may represent a request to act as an adapter. Server 302 retrieves a second script 352 at step 612. This may include, for example, adapter module 324 retrieving the second script 352 from repository 328. Server 302 communicates the second script 352 to gateway 304 at step 614. This may include, for example, adapter module 324 communicating the second script 352 to adapter module 326 using a proxy import command. This may also include adapter module 326 compiling/interpreting the second script 354. Server 302 invokes the first script 350 at step 616. The execution of the first script 350 invokes execution of the second script 352 in gateway 304 at step 618. This may include, for example, adapter module 324 communicating a proxy invocation command to adapter module 326. At this point, the executing scripts 350, 352 may exchange information to act as an adapter to integrate a resource 306.

Although FIG. 6 illustrates another example of a method 600 for integrating a resource at a first adapter, various changes may be made to FIG. 6. For example, while FIG. 6 assumes that a server 302 and a gateway 304 are collectively used to integrate a resource 306, the functionality described with respect to gateway 304 could be implemented in server 302.

FIG. 7 illustrates another example method 700 for integrating a resource at a second adapter. Method 700 may be described with respect to gateway 304 of FIG. 3. Method 700 could also be used by another device or devices in another system.

Gateway 304 receives a second script 352 from server 302 at step 702. This may include, for example, adapter module 326 receiving the second script 352 from adapter module 324. Gateway 304 compiles/interprets the second script 352 at step 704. This may include, for example, adapter module 326 interpreting a Jython script 352 into JAVA byte codes. Gateway 304 receives an instruction to invoke the second script 352 at step 706. Gateway 304 invokes the second script 352 at step 708. This may include, for example, adapter module 326 executing the JAVA byte codes generated at step 704. At this point, adapter module 326 may be executing script 352, and adapter module 324 in server 302 may be executing script 350. The executing scripts 350, 352 may exchange information to act as an adapter to integrate a resource 306.

Although FIG. 7 illustrates another example of a method 700 for integrating a resource at a second adapter, various changes may be made to FIG. 7. For example, while FIG. 7 assumes that a server 302 and a gateway 304 are collectively used to integrate a resource 306, the functionality described with respect to gateway 304 could be implemented in server 302.

FIG. 8 illustrates an example method 800 for persisting scripts in a database. Method 800 may be described with respect to server 202 of FIG. 2. Method 800 could also be used by another device or devices in another system. For example, method 800 could be used by server 302 to persist scripts in a database.

Server 202 compares a current script to a previously compiled or interpreted script at step 802. This may include, for example, adapter module 224 comparing a marker 278 associated with the binary version of a script 250 with a marker 280 associated with the source version of the script 250. Server 202 determines whether the compared scripts match at step 804. This may include, for example, adapter module 224 determining whether the markers 278, 280 contain the same date-time stamp.

If the markers 278, 280 match, the current script may not have changed since that script was compiled/interpreted earlier. Server 202 may retrieve the binary version of the script at step 806. This may include, for example, adapter module 224 retrieving the binary version of the script 250 from a cache 274. At this point, server 202 may use and process the binary version of the script 250.

If the markers 278, 280 do not match at step 804, the current script has changed since that script was compiled/interpreted. Server 202 compiles/interprets the newer script at step 808. This may include, for example, adapter module 224 generating JAVA byte codes. Server 202 stores the binary version of the newer script at step 810. This may include, for example, adapter module 224 replacing the older binary version of script 250 in cache 274 with the newer binary version generated at step 808. At this point, cache 274 contains an updated version of the script 250.

While this disclosure has been described in terms of certain embodiments and generally associated methods, alterations and permutations of the embodiments and methods will be apparent to those skilled in the art. Accordingly, the above description of example embodiments does not define or constrain this disclosure. Other changes, substitutions, and alterations are also possible without departing from the spirit and scope of this disclosure, as defined by the following claims. 

1-41. (canceled)
 42. A method for integrating a resource in a network, comprising: a first adaptor of a resource integration system receiving from a requesting entity a command associated with a function to be performed by a resource communicatively coupled to the resource integration system; the first adaptor generating a first set of byte codes responsive to receiving the command; a second adapter of the resource integration system generating a second set of byte codes; the first adaptor invoking execution of the first set of byte codes; and the first adaptor invoking execution of the second set of byte codes at the second adapter, the execution of the first and second sets of byte codes at the first and second adapters operable to invoke the function in the resource.
 43. The method of claim 42, wherein the first adaptor generating the first set of bytes codes includes: the first adaptor retrieving a first script from a storage resource of the resource integration system; and the first adaptor interpreting the first script to generate the first set of byte codes.
 44. The method of claim 43, wherein the second adaptor generating the second set of byte codes includes the second adaptor retrieving a second script from the storage resource and interpreting the second script.
 45. A system for integrating a resource in a network, comprising: at least one processor having access to a storage resource and operable to communicate to a first adapter of a resource integration system, the first adapter operable to: receive from a requesting entity a command associated with a function to be performed by a resource communicatively coupled to the resource integration system; receive a first script from the storage resource; cause a second adapter of the resource integration system to receive a second script from the storage resource; and execute the first script, wherein the execution of the first script invokes execution of the second script by the second adapter, the execution of the first and second scripts at the first and second adapters operable to invoke the function in the resource.
 46. The system of claim 45, wherein the first adaptor is configured to interpret the first script to generate a first set of byte codes and the second adapter is configured to interpret the second script to generate a second set of bytes codes.
 47. The system of claim 46, wherein executing the first script comprises executing the first set of bytes codes and wherein executing the second script comprises executing the second set of bytes codes.
 48. A system for integrating a resource in a network, comprising: executable instructions stored on a computer readable medium; and the instructions operable, when executed, to cause a first adaptor of a resource integration system to: receive from a requesting entity a command associated with a function to be performed by a resource communicatively coupled to a resource integration system; receive from one of (a) storage resource and (b) a second adaptor of the resource integration system a first script associated with the command; execute the first script; and invoke execution of a second script at the second adapter, the execution of the first and second scripts operable to invoke the function in the resource.
 49. A system for integrating a resource in a network, comprising: a storage resource operable to store a first script and a second script; a first adapter of a resource integration system operable to receive a command associated with a function to be performed by a resource communicatively coupled to the resource integration system, receive the first script from the storage resource, and execute the first script; a second adapter of the resource integration system operable to receive the second script from the storage resource, and execute the second script in response to the execution of the first script; and wherein the execution of the first and second scripts is operable to invoke the function in the resource.
 50. The system of claim 49, wherein executing the first script includes interpreting the first script to generate a first set of byte codes and executing the first set of byte codes and further executing the second script includes interpreting the second script to generate a second set of byte codes and executing the second set of byte codes. 